
package Indexador;

/**
 *
 * Indexador general, encargado de crear hijos y lanzarlos para que procesen código HTML obtenido
 * por el recolector, extrayendo temas de él.
 *
 * @author Mikel&Igor
 */
public class IndexadorPrincipal
{
    private int numHijos; //Número de indexadores que serán lanzados para trabajar en paralelo
    private int tiempoHijos; //Tiempo para los hijos

    /**
     * Número máximo de hijos que trabajarán en paralelo
     */
    public static final int maxHijos = 6;

    /**
     * Constructor por defecto. Será inicializado al máximo de hijos.
     */
    public IndexadorPrincipal()
    {
        numHijos = maxHijos;
    }

    /**
     * Constructor. Crea un IndexadorPrincipal.
     *
     * @param numHijos El número de hilos que lanzará.
     * @param tiempoHijos El tiempo configurado para los hijos.
     */
    public IndexadorPrincipal(int numHijos,int tiempoHijos)
    {
        this.numHijos = numHijos;
        this.tiempoHijos = tiempoHijos;
    }



    /**
     * Método para iniciar el indexado.
     */
    public void iniciar()
    {
        System.out.println("Iniciando Indexador. Lanzando "+numHijos+ " hilos. "
                + "Tiempo de espera de los workers: "+tiempoHijos +"\n\n");
        lanzarHijos();
    }

    /**
     * Método que lanzará los indexadores worker tras crearlos. Dado que
     * éstos se mantienen en ejecución eternamente, el método nunca acabará.
     */
    public void lanzarHijos()
    {
        int i;
        IndexadorWorker worker; //Indexador secundario

        for(i=0;i<numHijos;i++)
        {
            worker=new IndexadorWorker();
            worker.start();
        }
    }

    /**
     * Método main de ejecución del indexador principal. Con él se 
     * generarán los hilos indexadores y empezarán a trabajar.
     * 
     * @param args Toma como argumentos opcionales el número de hijos y el
     * tiempo que esperarán los hijos entre una petición y otra de página al
     * almacén temporal si la primera no devuelve nada.
     */
    public static void main(String args[])
    {
        int paramHijos=3,tiempo=3; //Número de hijos a lanzar y tiempo entre peticiones
        IndexadorPrincipal indexador;
        int posArgHijos = -1, posArgTiempo = -1; //Posición de los argumentos a leer. Si es -1 no hay que leer

        //Comprobación de argumentos. Si hay un número erróneo damos error
        if(args.length > 4 || args.length == 1 || args.length== 3)
        {
            System.out.println("Error en los argumentos: [-w <numero_de_hijos>] [-t <tiempo_de_espera>]");
            return;
        }

        //Si hay dos argumentos, es decir, un parámetro
        else if(args.length==2)
        {
            if(args[0].equals("-w")) //Número de hijos
                posArgHijos=1;
            else if(args[0].equals("-t")) //Tiempo
                posArgTiempo=1;
            else //Incorrecto
            {
                System.out.println("Error en los argumentos: [-w <numero_de_hijos>] [-t <tiempo_de_espera>]");
                return;
            }
        }

        //Si hay cuatro argumentos, los dos parámetros
        else if(args.length==4)
        {
            if(args[0].equals("-w")) //Número de hijos
                posArgHijos=1;
            else if(args[0].equals("-t")) //Tiempo
                posArgTiempo=1;
            else //Incorrecto
            {
                System.out.println("Error en los argumentos: [-w <numero_de_hijos>] [-t <tiempo_de_espera>]");
                return;
            }

            if(args[2].equals("-w")) //Número de hijos
                posArgHijos=3;
            else if(args[2].equals("-t")) //Tiempo
                posArgTiempo=3;
            else //Incorrecto
            {
                System.out.println("Error en los argumentos: [-w <numero_de_hijos>] [-t <tiempo_de_espera>]");
                return;
            }
        }

        //Conversión de los argumentos
        try
        {
            if(posArgTiempo != -1) //Si hay tiempo indicado
                tiempo = Integer.parseInt(args[posArgTiempo]);

            if(posArgHijos != -1)
                paramHijos = Integer.parseInt(args[posArgHijos]);

        }
        catch(NumberFormatException ex)
        {
            //Si el usuario ha introducido un valor no numérico damos error y salimos
            System.out.println("Los parámetros deben ser números enteros"+
                    IndexadorPrincipal.maxHijos);
            return;
        }

        //Si el valor número de hijos no es correcto
        if(paramHijos < 1 || paramHijos > IndexadorPrincipal.maxHijos)
        {
            System.out.println("El número de hijos debe ser un entero entre 1 y "+IndexadorPrincipal.maxHijos);
            return;
        }

        //Si el tiempo no es correcto
        if(tiempo < 1)
        {
            System.out.println("El tiempo debe ser un entero mayor que 1");
            return;
        }

        //Si todo funciona correctamente iniciamos el indexador
        indexador=new IndexadorPrincipal(paramHijos,tiempo); //Crear el indexador
        indexador.iniciar(); //Iniciar el indexado
    }
}
